/**
 * 头像管理器
 * 负责下载、缓存和管理用户头像
 */

const path = require('path');
const fs = require('fs').promises;
const fsSync = require('fs');
const axios = require('axios');
const crypto = require('crypto');
const { app } = require('electron');
const logger = require('./logger');

class AvatarManager {
  constructor() {
    // 头像缓存目录
    this.cacheDir = path.join(app.getPath('userData'), 'avatars');
    this.defaultAvatar = path.join(__dirname, '../renderer/assets/avatar.png');
    
    // 确保缓存目录存在
    this.initCacheDir();
  }

  /**
   * 初始化缓存目录
   */
  async initCacheDir() {
    try {
      await fs.mkdir(this.cacheDir, { recursive: true });
      logger.info('[头像管理器] 缓存目录已创建:', this.cacheDir);
    } catch (error) {
      logger.error('[头像管理器] 创建缓存目录失败:', error);
    }
  }

  /**
   * 生成URL的哈希值作为缓存文件名
   */
  getUrlHash(url) {
    return crypto.createHash('md5').update(url).digest('hex');
  }

  /**
   * 获取缓存文件路径
   */
  getCachePath(url) {
    const hash = this.getUrlHash(url);
    const ext = path.extname(url).split('?')[0] || '.jpg';
    return path.join(this.cacheDir, `${hash}${ext}`);
  }

  /**
   * 检查缓存是否存在
   */
  async isCached(url) {
    if (!url) return false;
    
    try {
      const cachePath = this.getCachePath(url);
      await fs.access(cachePath);
      return true;
    } catch (error) {
      return false;
    }
  }

  /**
   * 下载头像到缓存
   */
  async downloadAvatar(url) {
    if (!url) {
      logger.warn('[头像管理器] URL为空，使用默认头像');
      return this.defaultAvatar;
    }

    try {
      const cachePath = this.getCachePath(url);

      // 检查是否已缓存
      if (await this.isCached(url)) {
        logger.info('[头像管理器] 使用缓存头像:', cachePath);
        return cachePath;
      }

      logger.info('[头像管理器] 开始下载头像:', url);

      // 下载头像
      const response = await axios.get(url, {
        responseType: 'arraybuffer',
        timeout: 10000,
        headers: {
          'User-Agent': 'FileSync-Client/1.0'
        }
      });

      // 保存到缓存
      await fs.writeFile(cachePath, response.data);
      logger.info('[头像管理器] 头像下载成功:', cachePath);

      return cachePath;
    } catch (error) {
      logger.error('[头像管理器] 下载头像失败:', error.message);
      return this.defaultAvatar;
    }
  }

  /**
   * 获取头像路径（优先使用缓存）
   */
  async getAvatarPath(url) {
    if (!url) {
      return this.defaultAvatar;
    }

    const cachePath = this.getCachePath(url);

    // 如果已缓存，直接返回
    if (await this.isCached(url)) {
      return cachePath;
    }

    // 否则下载
    return await this.downloadAvatar(url);
  }

  /**
   * 清除所有缓存
   */
  async clearCache() {
    try {
      const files = await fs.readdir(this.cacheDir);
      for (const file of files) {
        await fs.unlink(path.join(this.cacheDir, file));
      }
      logger.info('[头像管理器] 缓存已清除');
    } catch (error) {
      logger.error('[头像管理器] 清除缓存失败:', error);
    }
  }

  /**
   * 清除指定URL的缓存
   */
  async clearAvatarCache(url) {
    if (!url) return;

    try {
      const cachePath = this.getCachePath(url);
      await fs.unlink(cachePath);
      logger.info('[头像管理器] 已删除缓存:', cachePath);
    } catch (error) {
      logger.error('[头像管理器] 删除缓存失败:', error);
    }
  }

  /**
   * 获取缓存统计信息
   */
  async getCacheStats() {
    try {
      const files = await fs.readdir(this.cacheDir);
      let totalSize = 0;

      for (const file of files) {
        const filePath = path.join(this.cacheDir, file);
        const stats = await fs.stat(filePath);
        totalSize += stats.size;
      }

      return {
        count: files.length,
        totalSize,
        totalSizeMB: (totalSize / 1024 / 1024).toFixed(2)
      };
    } catch (error) {
      logger.error('[头像管理器] 获取缓存统计失败:', error);
      return { count: 0, totalSize: 0, totalSizeMB: '0.00' };
    }
  }
}

// 导出单例
module.exports = new AvatarManager();
